rung-tools / rung-cli

import fs from 'fs';

import { promisify, props, resolve } from 'bluebird';

import {

    T,

    __,

    assoc,

    concat,

    cond,

    contains,

    curry,

    filter as filterWhere,

    has,

    keys,

    map,

    mapObjIndexed,

    merge,

    pathEq,

    reduce,

    toPairs,

    when

} from 'ramda';

import { cyan, green, red, yellow } from 'colors/safe';

import { createPromptModule } from 'inquirer';

import { validator, filter } from './types';

import getAutocompleteSources, { compileClosure } from './autocomplete';

/**

 * Emits an info message to stdout

 *

 * @param {String} message

 * @return {Promise}

 */

export const emitInfo = concat(' ℹ Info: ') & cyan & console.log & resolve;

/**

 * Emits a warning to stdout

 *

 * @param {String} message

 * @return {Promise}

 */

export const emitWarning = concat(' ⚠ Warning: ') & yellow & console.log & resolve;

/**

 * Emits an error to stdout

 *

 * @param {String} message

 * @return {Promise}

 */

export const emitError = concat(' ✗ Error: ') & red & console.log & resolve;

/**

 * Emits a success message

 *

 * @param {String} message

 * @return {Promise}

 */

export const emitSuccess = concat(' ✔ Success: ') & green & console.log & resolve;

/**

 * Renames the keys of an object

 *

 * @sig {a: b} -> {a: *} -> {b: *}

 */

const renameKeys = curry((keysMap, obj) => reduce((acc, key) =>

    assoc(keysMap[key] || key, obj[key], acc), {}, keys(obj)));

const objectToChoices = toPairs & map(([value, name]) => ({ name, value }));

export const components = {

    Calendar: ~{

        type: 'datetime',

        format: ['m', '/', 'd', '/', 'yy'],

        filter: filter.Calendar },

    Char: ({ length }) => ({ filter: filter.Char(length) }),

    Checkbox: ~{ type: 'confirm' },

    Color: ~{

        type: 'chalk-pipe',

        validate: validator.Color },

    DoubleRange: ({ from, to }) => ({

        filter: filter.Double,

        validate: validator.Range(from, to) }),

    DateTime: ~{ type: 'datetime' },

    Double: ~{ validate: validator.Double, filter: filter.Double },

    Email: ~{ validate: validator.Email },

    Integer: ~{ validate: validator.Integer, filter: filter.Integer },

    IntegerRange: ({ from, to }) => ({

        filter: filter.Integer,

        validate: validator.Range(from, to) }),

    IntegerMultiRange: ({ from, to }) => ({

        filter: filter.IntegerMultiRange,

        validate: validator.IntegerMultiRange(from, to) }),

    Natural: ~{ validate: validator.Natural, filter: filter.Integer },

    OneOf: ({ values }) => ({

        type: 'list',

        choices: values,

        validate: validator.OneOf(values) }),

    String: ~{ type: 'input' },

    Url: ~{ validate: validator.Url },

    Money: ~{ validate: validator.Money, filter: filter.Money },

    SelectBox: ({ values }) => ({

        type: 'list',

        choices: objectToChoices(values) }),

    MultiSelectBox: ({ values }) => ({

        type: 'checkbox',

        choices: objectToChoices(values) }),

    File: ~{ type: 'filePath', basePath: process.cwd() }

};

/**

 * Custom autocomplete component

 *

 * @param {String} name

 * @param {String} source

 * @return {Function}

 */

const getAutocompleteComponent = (name, source) => {

    if (!source) {

        throw new Error(`aren't you missing 'autocomplete/${name}.js'?`);

    }

    return ~{ type: 'autocomplete', source: compileClosure(name, source) };

};

/**

 * Converts a Rung CLI question object to an Inquirer question object

 *

 * @author Marcelo Haskell Camargo

 * @param {String[]} sources

 * @return {Object}

 */

const toInquirerQuestion = curry((sources, [name, config]) => {

    const component = components

        | cond([

            [~(config.type.name === 'AutoComplete'), ~getAutocompleteComponent(name, sources[name])],

            [T, _.String]

        ]);

    return merge(config

        | renameKeys({ description: 'message' })

        | merge(__, { name }), component(config.type));

});

const readFile = promisify(fs.readFile);

/**

 * Opens the provided files and returns them as node buffers

 *

 * @param {String[]} fields

 * @return {Promise}

 */

const openFiles = fields =>

    mapObjIndexed((value, param) => value

        | when(~contains(param, fields), concat(process.cwd() + '/') & readFile))

    & props;

/**

 * Returns the pure JS values from received questions that will be answered

 *

 * @author Marcelo Haskell Camargo

 * @param {Object} questions

 * @return {Promise} answers for the questions by key

 */